import parseAttrString from './parseAttrString'
// parse函数，主函数
export default function (templateString) {
  // 指针
  var index = 0,
    rest = ''
  // 开始标记
  var startRegExp = /^\<([a-z]+[1-6]?)(\s[^\<]+)?\>/
  // 结束标记
  var endRegExp = /^\<\/([a-z]+[1-6]?)\>/
  // 抓取结束标签前的文字
  var wordRegExp = /^([^\<]+)\<\/[a-z]+[1-6]?\>/
  // 准备两个栈
  var stack1 = [],
    stack2 = [{ children: [] }]
  while (index < templateString.length - 1) {
    rest = templateString.substring(index)
    // 识别遍历到这个字符，是不是一个开始标签
    if (startRegExp.test(rest)) {
      //抓取到开始标签
      let tag = rest.match(startRegExp)[1]
      let attrString = rest.match(startRegExp)[2]
      // console.log('开始标记', tag)
      // 将离开时标记推入栈1中，将空数组推入栈2中
      stack1.push(tag)
      stack2.push({
        tag: tag,
        children: [],
        attrs:parseAttrString(attrString)
      })
      // 指针移动标签长度加2再加attrString.length，为什么加2因为<>占两个字符
      // attrString长度
      const attrStringLength = attrString != null?attrString.length:0
      index += tag.length + 2 + attrStringLength
    } else if (endRegExp.test(rest)) {
      //抓取到结束标签
      let tag = rest.match(endRegExp)[1]
      // console.log('结束标记', tag)
      let pop_tag = stack1.pop()
      // 此时tag一定是和栈1顶部的是相同的
      if (tag === pop_tag) {
        let pop_arr = stack2.pop()
        if (stack2.length > 0) {
          stack2[stack2.length - 1].children.push(pop_arr)
        }
      } else {
        throw new Error(pop_tag + '标签没有封闭！')
      }
      // 指针移动标签长度加2，为什么加2因为</>占三个字符
      index += tag.length + 3
    } else if (wordRegExp.test(rest)) {
      //抓取文字
      // 识别遍历到的这个字符，是不是文字
      let word = rest.match(wordRegExp)[1]
      // 看word是不是全控
      if (!/^\s+$/.test(word)) {
        //不是全空
        // console.log('文字：' + word)
        // 推入到stack2栈顶元素中
        stack2[stack2.length - 1].children.push({
          text: word,
          type: 3,
        })
      }
      index += word.length
    } else {
      // 标签中的文字
      index++
    }
  }
  // 此时stack2就是之前默认放置的一项了，此时要返回则一项的children就可以了
  return stack2[0].children[0]
}
